# Setting batch to true, triggers one build at a time.
# if there is a push while a build in progress, it will wait,
# until the running build finishes, and produce a build with all the changes
# that happened during the last build.
trigger:
  batch: true
  branches:
    include:
    - release/*.*
  paths:
    include:
    - '*'
    exclude:
    - '**.md'
    - eng/Version.Details.xml
    - .devcontainer/*
    - .github/*
    - docs/*
    - LICENSE.TXT
    - PATENTS.TXT
    - THIRD-PARTY-NOTICES.TXT
    - eng/pipelines/coreclr/perf*yml
    - eng/pipelines/coreclr/templates/build-perf*
    - eng/pipelines/coreclr/templates/perf-job.yml
    - eng/pipelines/coreclr/templates/run-perf*
    - eng/testing/performance/*

schedules:
  - cron: "0 8,20 * * *" # run at 8:00 and 20:00 (UTC) which is 00:00 and 12:00 (PST).
    displayName: Runtime default schedule
    branches:
      include:
      - main
    always: false # run only if there were changes since the last successful scheduled run.

pr:
  branches:
    include:
    - main
    - release/*.*
  paths:
    include:
    - '*'
    exclude:
    - '**.md'
    - eng/Version.Details.xml
    - .devcontainer/*
    - .github/*
    - docs/*
    - LICENSE.TXT
    - PATENTS.TXT
    - THIRD-PARTY-NOTICES.TXT

variables:
  - template: /eng/pipelines/common/variables.yml

extends:
  template:  /eng/pipelines/common/templates/pipeline-with-resources.yml
  parameters:
    stages:
    - ${{ if eq(variables['Build.Reason'], 'PullRequest') }}:
      - stage: EvaluatePaths
        displayName: Evaluate Paths
        jobs:
          - template: /eng/pipelines/common/evaluate-default-paths.yml

    - stage: Build
      jobs:

      #
      # Build CoreCLR verticals where we don't run host tests
      #
      - template: /eng/pipelines/common/platform-matrix.yml
        parameters:
          jobTemplate: /eng/pipelines/common/global-build-job.yml
          buildConfig: ${{ variables.debugOnPrReleaseOnRolling }}
          platforms:
          - linux_musl_arm
          - linux_musl_arm64
          - windows_arm64
          - linux_arm
          jobParameters:
            nameSuffix: AllSubsets_CoreCLR_ReleaseRuntimeLibs
            buildArgs: -s clr+libs+host+packs -rc Release -lc Release -c $(_BuildConfig)
            timeoutInMinutes: 120
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_non_mono_and_wasm.containsChange'], true),
                eq(variables['isRollingBuild'], true))

      - template: /eng/pipelines/common/platform-matrix.yml
        parameters:
          jobTemplate: /eng/pipelines/common/global-build-job.yml
          buildConfig: ${{ variables.debugOnPrReleaseOnRolling }}
          platforms:
          - osx_arm64
          - linux_arm64
          - linux_musl_x64
          jobParameters:
            nameSuffix: AllSubsets_CoreCLR
            buildArgs: -s clr+libs+host+packs -rc Release -c Release -lc $(_BuildConfig)
            timeoutInMinutes: 120
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_non_mono_and_wasm.containsChange'], true),
                eq(variables['isRollingBuild'], true))

      #
      # Build CoreCLR and Libraries with Libraries tests
      # For running libraries tests and installer tests
      #
      - template: /eng/pipelines/common/platform-matrix.yml
        parameters:
          jobTemplate: /eng/pipelines/common/global-build-job.yml
          buildConfig: ${{ variables.debugOnPrReleaseOnRolling }}
          platforms:
          - linux_x64
          - linux_musl_x64
          - osx_x64
          - windows_x64
          jobParameters:
            nameSuffix: CoreCLR_Libraries
            buildArgs: -s clr+libs+libs.tests -rc Release -c $(_BuildConfig) /p:ArchiveTests=true
            timeoutInMinutes: 120
            postBuildSteps:
              - template: /eng/pipelines/common/upload-artifact-step.yml
                parameters:
                  rootFolder: $(Build.SourcesDirectory)/artifacts/bin
                  includeRootFolder: false
                  archiveType: $(archiveType)
                  archiveExtension: $(archiveExtension)
                  tarCompression: $(tarCompression)
                  artifactName: CoreCLR_Libraries_BuildArtifacts_$(osGroup)$(osSubgroup)_$(archType)_$(_BuildConfig)
                  displayName: Build Assets
              - template: /eng/pipelines/common/upload-artifact-step.yml
                parameters:
                  rootFolder: $(Build.SourcesDirectory)/artifacts/helix
                  includeRootFolder: false
                  archiveType: $(archiveType)
                  archiveExtension: $(archiveExtension)
                  tarCompression: $(tarCompression)
                  artifactName: CoreCLR_Libraries_TestArtifacts_$(osGroup)$(osSubgroup)_$(archType)_$(_BuildConfig)
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_non_mono_and_wasm.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_libraries.containsChange'], true),
                eq(variables['isRollingBuild'], true))

      - template: /eng/pipelines/common/platform-matrix.yml
        parameters:
          jobTemplate: /eng/pipelines/common/global-build-job.yml
          buildConfig: release
          platforms:
          - windows_x86
          jobParameters:
            nameSuffix: CoreCLR_Libraries
            buildArgs: -s clr+libs+libs.tests -c $(_BuildConfig) /p:ArchiveTests=true
            timeoutInMinutes: 120
            postBuildSteps:
              - template: /eng/pipelines/common/upload-artifact-step.yml
                parameters:
                  rootFolder: $(Build.SourcesDirectory)/artifacts/bin
                  includeRootFolder: false
                  archiveType: $(archiveType)
                  archiveExtension: $(archiveExtension)
                  tarCompression: $(tarCompression)
                  artifactName: CoreCLR_Libraries_BuildArtifacts_$(osGroup)$(osSubgroup)_$(archType)_$(_BuildConfig)
                  displayName: Build Assets
              - template: /eng/pipelines/common/upload-artifact-step.yml
                parameters:
                  rootFolder: $(Build.SourcesDirectory)/artifacts/helix
                  includeRootFolder: false
                  archiveType: $(archiveType)
                  archiveExtension: $(archiveExtension)
                  tarCompression: $(tarCompression)
                  artifactName: CoreCLR_Libraries_TestArtifacts_$(osGroup)$(osSubgroup)_$(archType)_$(_BuildConfig)
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_non_mono_and_wasm.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_libraries.containsChange'], true),
                eq(variables['isRollingBuild'], true))

      #
      # Build CoreCLR and Libraries with the respective tests
      # for the test configurations we run.
      #
      - template: /eng/pipelines/common/platform-matrix.yml
        parameters:
          jobTemplate: /eng/pipelines/common/global-build-job.yml
          buildConfig: ${{ variables.debugOnPrReleaseOnRolling }}
          platforms:
          - linux_arm64
          - osx_x64
          jobParameters:
            nameSuffix: Libraries_CheckedCoreCLR
            buildArgs: -s clr+libs+libs.tests -c $(_BuildConfig) -rc Checked /p:ArchiveTests=true
            timeoutInMinutes: 120
            postBuildSteps:
              - template: /eng/pipelines/coreclr/templates/build-native-test-assets-step.yml
              - template: /eng/pipelines/common/upload-artifact-step.yml
                parameters:
                  rootFolder: $(Build.SourcesDirectory)/artifacts/bin
                  includeRootFolder: false
                  archiveType: $(archiveType)
                  archiveExtension: $(archiveExtension)
                  tarCompression: $(tarCompression)
                  artifactName: Libraries_CheckedCoreCLR_BuildArtifacts_$(osGroup)$(osSubgroup)_$(archType)_$(_BuildConfig)
                  displayName: Build Assets
              - template: /eng/pipelines/common/upload-artifact-step.yml
                parameters:
                  rootFolder: $(Build.SourcesDirectory)/artifacts/helix
                  includeRootFolder: false
                  archiveType: $(archiveType)
                  archiveExtension: $(archiveExtension)
                  tarCompression: $(tarCompression)
                  artifactName: Libraries_CheckedCoreCLR_TestArtifacts_$(osGroup)$(osSubgroup)_$(archType)_$(_BuildConfig)
            extraVariablesTemplates:
              - template: /eng/pipelines/common/templates/runtimes/native-test-assets-variables.yml
                parameters:
                  testGroup: innerloop
                  configOverride: Checked
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_coreclr.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_libraries.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_runtimetests.containsChange'], true),
                eq(variables['isRollingBuild'], true))

      - template: /eng/pipelines/common/platform-matrix.yml
        parameters:
          jobTemplate: /eng/pipelines/common/global-build-job.yml
          buildConfig: ${{ variables.debugOnPrReleaseOnRolling }}
          platforms:
          - linux_x64
          - windows_x64
          jobParameters:
            nameSuffix: Libraries_CheckedCoreCLR
            buildArgs: -s clr+libs -c $(_BuildConfig) -rc Checked
            timeoutInMinutes: 120
            postBuildSteps:
              - template: /eng/pipelines/coreclr/templates/build-native-test-assets-step.yml
              - template: /eng/pipelines/common/upload-artifact-step.yml
                parameters:
                  rootFolder: $(Build.SourcesDirectory)/artifacts/bin
                  includeRootFolder: false
                  archiveType: $(archiveType)
                  archiveExtension: $(archiveExtension)
                  tarCompression: $(tarCompression)
                  artifactName: Libraries_CheckedCoreCLR_BuildArtifacts_$(osGroup)$(osSubgroup)_$(archType)_$(_BuildConfig)
                  displayName: Build Assets
            extraVariablesTemplates:
              - template: /eng/pipelines/common/templates/runtimes/native-test-assets-variables.yml
                parameters:
                  testGroup: innerloop
                  configOverride: Checked
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_coreclr.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_runtimetests.containsChange'], true),
                eq(variables['isRollingBuild'], true))

      - template: /eng/pipelines/common/platform-matrix.yml
        parameters:
          jobTemplate: /eng/pipelines/common/global-build-job.yml
          buildConfig: ${{ variables.debugOnPrReleaseOnRolling }}
          platforms:
          - linux_musl_x64
          - windows_x86
          jobParameters:
            nameSuffix: Libraries_CheckedCoreCLR
            buildArgs: -s clr+libs+libs.tests -c $(_BuildConfig) -rc Checked /p:ArchiveTests=true
            timeoutInMinutes: 120
            postBuildSteps:
              - template: /eng/pipelines/common/upload-artifact-step.yml
                parameters:
                  rootFolder: $(Build.SourcesDirectory)/artifacts/bin
                  includeRootFolder: false
                  archiveType: $(archiveType)
                  archiveExtension: $(archiveExtension)
                  tarCompression: $(tarCompression)
                  artifactName: Libraries_CheckedCoreCLR_BuildArtifacts_$(osGroup)$(osSubgroup)_$(archType)_$(_BuildConfig)
                  displayName: Build Assets
              - template: /eng/pipelines/common/upload-artifact-step.yml
                parameters:
                  rootFolder: $(Build.SourcesDirectory)/artifacts/helix
                  includeRootFolder: false
                  archiveType: $(archiveType)
                  archiveExtension: $(archiveExtension)
                  tarCompression: $(tarCompression)
                  artifactName: Libraries_CheckedCoreCLR_TestArtifacts_$(osGroup)$(osSubgroup)_$(archType)_$(_BuildConfig)
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_coreclr.containsChange'], true),
                eq(variables['isRollingBuild'], true))

      - template: /eng/pipelines/common/platform-matrix.yml
        parameters:
          jobTemplate: /eng/pipelines/common/global-build-job.yml
          buildConfig: ${{ variables.debugOnPrReleaseOnRolling }}
          platforms:
          - osx_arm64
          jobParameters:
            nameSuffix: Libraries_CheckedCoreCLR
            buildArgs: -s clr+libs -c $(_BuildConfig) -rc Checked
            timeoutInMinutes: 120
            postBuildSteps:
              - template: /eng/pipelines/coreclr/templates/build-native-test-assets-step.yml
              - template: /eng/pipelines/common/upload-artifact-step.yml
                parameters:
                  rootFolder: $(Build.SourcesDirectory)/artifacts/bin
                  includeRootFolder: false
                  archiveType: $(archiveType)
                  archiveExtension: $(archiveExtension)
                  tarCompression: $(tarCompression)
                  artifactName: Libraries_CheckedCoreCLR_BuildArtifacts_$(osGroup)$(osSubgroup)_$(archType)_$(_BuildConfig)
                  displayName: Build Assets
            extraVariablesTemplates:
              - template: /eng/pipelines/common/templates/runtimes/native-test-assets-variables.yml
                parameters:
                  testGroup: innerloop
                  configOverride: Checked
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_coreclr_AppleSilicon.containsChange'], true),
                eq(variables['isRollingBuild'], true))

      - template: /eng/pipelines/common/platform-matrix.yml
        parameters:
          jobTemplate: /eng/pipelines/common/global-build-job.yml
          buildConfig: checked
          platforms:
          - linux_arm
          - windows_arm64
          - windows_x86
          jobParameters:
            nameSuffix: CoreCLR_ReleaseLibraries
            buildArgs: -s clr+libs -rc $(_BuildConfig) -c Release
            timeoutInMinutes: 120
            postBuildSteps:
              - template: /eng/pipelines/coreclr/templates/build-native-test-assets-step.yml
              - template: /eng/pipelines/common/upload-artifact-step.yml
                parameters:
                  rootFolder: $(Build.SourcesDirectory)/artifacts/bin
                  includeRootFolder: false
                  archiveType: $(archiveType)
                  archiveExtension: $(archiveExtension)
                  tarCompression: $(tarCompression)
                  artifactName: CoreCLR_ReleaseLibraries_BuildArtifacts_$(osGroup)$(osSubgroup)_$(archType)_$(_BuildConfig)
                  displayName: Build Assets
            extraVariablesTemplates:
              - template: /eng/pipelines/common/templates/runtimes/native-test-assets-variables.yml
                parameters:
                  testGroup: innerloop
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_coreclr.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_runtimetests.containsChange'], true),
                eq(variables['isRollingBuild'], true))

      - template: /eng/pipelines/common/platform-matrix.yml
        parameters:
          jobTemplate: /eng/pipelines/common/global-build-job.yml
          buildConfig: checked
          platforms:
          - linux_x64
          - linux_musl_arm
          - linux_musl_arm64
          - windows_x64
          jobParameters:
            nameSuffix: CoreCLR_ReleaseLibraries
            buildArgs: -s clr+libs+libs.tests -rc $(_BuildConfig) -c Release /p:ArchiveTests=true
            timeoutInMinutes: 120
            postBuildSteps:
              - template: /eng/pipelines/common/upload-artifact-step.yml
                parameters:
                  rootFolder: $(Build.SourcesDirectory)/artifacts/bin
                  includeRootFolder: false
                  archiveType: $(archiveType)
                  archiveExtension: $(archiveExtension)
                  tarCompression: $(tarCompression)
                  artifactName: CoreCLR_ReleaseLibraries_BuildArtifacts_$(osGroup)$(osSubgroup)_$(archType)_$(_BuildConfig)
                  displayName: Build Assets
              - template: /eng/pipelines/common/upload-artifact-step.yml
                parameters:
                  rootFolder: $(Build.SourcesDirectory)/artifacts/helix
                  includeRootFolder: false
                  archiveType: $(archiveType)
                  archiveExtension: $(archiveExtension)
                  tarCompression: $(tarCompression)
                  artifactName: CoreCLR_ReleaseLibraries_TestArtifacts_$(osGroup)$(osSubgroup)_$(archType)_$(_BuildConfig)
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_coreclr.containsChange'], true),
                eq(variables['isRollingBuild'], true))

      #
      # Build the whole product using GNU compiler toolchain
      # When CoreCLR, Mono, Libraries, Installer and src/tests are changed
      #
      - template: /eng/pipelines/common/platform-matrix.yml
        parameters:
          jobTemplate: /eng/pipelines/common/global-build-job.yml
          buildConfig: checked
          platforms:
          - gcc_linux_x64
          jobParameters:
            testGroup: innerloop
            nameSuffix: Native_GCC
            buildArgs: -s clr.native+libs.native+mono+host.native -c $(_BuildConfig) -gcc
            postBuildSteps:
              - template: /eng/pipelines/common/templates/runtimes/build-runtime-tests.yml
                parameters:
                  testBuildArgs: skipmanaged skipgeneratelayout skiprestorepackages -gcc
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_coreclr.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_mono_excluding_wasm.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_libraries.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_installer.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_runtimetests.containsChange'], true),
                eq(variables['isRollingBuild'], true))

      #
      # Build CoreCLR Formatting Job
      # Only when CoreCLR is changed, and only in the 'main' branch (no release branches;
      # both Rolling and PR builds).
      #
      - template: /eng/pipelines/common/platform-matrix.yml
        parameters:
          jobTemplate: /eng/pipelines/coreclr/templates/format-job.yml
          platforms:
          - linux_x64
          - windows_x64
          jobParameters:
            condition: >-
              and(
                or(
                  eq(variables['Build.SourceBranchName'], 'main'),
                  eq(variables['System.PullRequest.TargetBranch'], 'main')),
                or(
                  eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_coreclr_jit.containsChange'], true),
                  eq(variables['isRollingBuild'], true)))

      #
      # Build CoreCLR with no R2R
      #
      - template: /eng/pipelines/common/platform-matrix.yml
        parameters:
          jobTemplate: /eng/pipelines/common/global-build-job.yml
          helixQueuesTemplate: /eng/pipelines/libraries/helix-queues-setup.yml
          buildConfig: checked
          runtimeFlavor: coreclr
          platforms:
          - linux_x86
          jobParameters:
            testScope: innerloop
            nameSuffix: CoreCLR_NoR2R
            buildArgs: -s clr.runtime+clr.jit+clr.iltools+clr.spmi+clr.corelib -c $(_BuildConfig)
            timeoutInMinutes: 120
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_coreclr.containsChange'], true),
                eq(variables['isRollingBuild'], true))

      #
      # Build CoreCLR as a non-portable build
      #
      - template: /eng/pipelines/common/platform-matrix.yml
        parameters:
          jobTemplate: /eng/pipelines/common/global-build-job.yml
          helixQueuesTemplate: /eng/pipelines/libraries/helix-queues-setup.yml
          buildConfig: checked
          runtimeFlavor: coreclr
          platforms:
          - tizen_armel
          jobParameters:
            testScope: innerloop
            nameSuffix: CoreCLR_NonPortable
            buildArgs: -s clr.native+clr.tools+clr.corelib+clr.nativecorelib+clr.aot+clr.packages -c $(_BuildConfig) /p:PortableBuild=false
            timeoutInMinutes: 120
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_coreclr.containsChange'], true),
                eq(variables['isRollingBuild'], true))

      #
      # Build CoreCLR without building test assets
      #
      - template: /eng/pipelines/common/platform-matrix.yml
        parameters:
          jobTemplate: /eng/pipelines/common/global-build-job.yml
          helixQueuesTemplate: /eng/pipelines/libraries/helix-queues-setup.yml
          buildConfig: checked
          runtimeFlavor: coreclr
          platforms:
          - linux_riscv64
          jobParameters:
            testScope: innerloop
            nameSuffix: CoreCLR
            buildArgs: -s clr.native+clr.tools+clr.corelib+clr.nativecorelib+clr.aot+clr.packages -c $(_BuildConfig)
            timeoutInMinutes: 120
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_coreclr.containsChange'], true),
                eq(variables['isRollingBuild'], true))

      #
      # Build CoreCLR + Libs + Host + Packs
      #
      - template: /eng/pipelines/common/platform-matrix.yml
        parameters:
          jobTemplate: /eng/pipelines/common/global-build-job.yml
          helixQueuesTemplate: /eng/pipelines/libraries/helix-queues-setup.yml
          buildConfig: ${{ variables.debugOnPrReleaseOnRolling }}
          runtimeFlavor: coreclr
          platforms:
          - freebsd_x64
          jobParameters:
            testScope: innerloop
            nameSuffix: CoreCLR
            buildArgs: -s clr+libs+host+packs -c $(_BuildConfig) -rc Checked
            timeoutInMinutes: 120
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_coreclr.containsChange'], true),
                eq(variables['isRollingBuild'], true))

      #
      # CoreCLR NativeAOT debug build and smoke tests
      # Only when CoreCLR is changed
      #
      - template: /eng/pipelines/common/platform-matrix.yml
        parameters:
          jobTemplate: /eng/pipelines/common/global-build-job.yml
          helixQueuesTemplate: /eng/pipelines/coreclr/templates/helix-queues-setup.yml
          buildConfig: Debug
          platforms:
          - linux_x64
          - windows_x64
          variables:
          - name: timeoutPerTestInMinutes
            value: 60
          - name: timeoutPerTestCollectionInMinutes
            value: 180
          jobParameters:
            timeoutInMinutes: 120
            nameSuffix: NativeAOT
            buildArgs: -s clr.aot+host.native+libs -rc $(_BuildConfig) -lc Release -hc Release /p:RunAnalyzers=false
            postBuildSteps:
              - template: /eng/pipelines/coreclr/nativeaot-post-build-steps.yml
                parameters:
                  creator: dotnet-bot
                  testBuildArgs: nativeaot tree nativeaot
                  liveLibrariesBuildConfig: Release
                  testRunNamePrefixSuffix: NativeAOT_$(_BuildConfig)
            extraVariablesTemplates:
              - template: /eng/pipelines/common/templates/runtimes/test-variables.yml
                parameters:
                  testGroup: innerloop
                  liveLibrariesBuildConfig: Release
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_coreclr.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_runtimetests.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_tools_illink.containsChange'], true),
                eq(variables['isRollingBuild'], true))

      #
      # CoreCLR NativeAOT checked build and smoke tests
      # Only when CoreCLR is changed
      #
      - template: /eng/pipelines/common/platform-matrix.yml
        parameters:
          jobTemplate: /eng/pipelines/common/global-build-job.yml
          helixQueuesTemplate: /eng/pipelines/coreclr/templates/helix-queues-setup.yml
          buildConfig: Checked
          platforms:
          - windows_x64
          variables:
          - name: timeoutPerTestInMinutes
            value: 60
          - name: timeoutPerTestCollectionInMinutes
            value: 180
          jobParameters:
            timeoutInMinutes: 180
            nameSuffix: NativeAOT
            buildArgs: -s clr.aot+host.native+libs.native+libs.sfx -rc $(_BuildConfig) -lc Release -hc Release /p:RunAnalyzers=false
            postBuildSteps:
              - template: /eng/pipelines/coreclr/nativeaot-post-build-steps.yml
                parameters:
                  creator: dotnet-bot
                  testBuildArgs: 'nativeaot tree ";nativeaot;Loader;Interop;" /p:BuildNativeAotFrameworkObjects=true'
                  liveLibrariesBuildConfig: Release
                  testRunNamePrefixSuffix: NativeAOT_$(_BuildConfig)
            extraVariablesTemplates:
              - template: /eng/pipelines/common/templates/runtimes/test-variables.yml
                parameters:
                  testGroup: innerloop
                  liveLibrariesBuildConfig: Release
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_coreclr.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_runtimetests.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_tools_illink.containsChange'], true),
                eq(variables['isRollingBuild'], true))

      #
      # CoreCLR NativeAOT release build and smoke tests
      # Only when CoreCLR is changed
      #
      - template: /eng/pipelines/common/platform-matrix.yml
        parameters:
          jobTemplate: /eng/pipelines/common/global-build-job.yml
          helixQueuesTemplate: /eng/pipelines/coreclr/templates/helix-queues-setup.yml
          buildConfig: Release
          platforms:
          - linux_x64
          - windows_x64
          - osx_x64
          - linux_arm64
          - windows_arm64
          - osx_arm64
          variables:
          - name: timeoutPerTestInMinutes
            value: 60
          - name: timeoutPerTestCollectionInMinutes
            value: 180
          jobParameters:
            testGroup: innerloop
            timeoutInMinutes: 120
            nameSuffix: NativeAOT
            buildArgs: -s clr.aot+host.native+libs+tools.illink -c $(_BuildConfig) -rc $(_BuildConfig) -lc Release -hc Release /p:RunAnalyzers=false
            postBuildSteps:
              - template: /eng/pipelines/coreclr/nativeaot-post-build-steps.yml
                parameters:
                  creator: dotnet-bot
                  testBuildArgs: 'nativeaot tree ";nativeaot;tracing/eventpipe/providervalidation;"'
                  liveLibrariesBuildConfig: Release
                  testRunNamePrefixSuffix: NativeAOT_$(_BuildConfig)
            extraVariablesTemplates:
              - template: /eng/pipelines/common/templates/runtimes/test-variables.yml
                parameters:
                  testGroup: innerloop
                  liveLibrariesBuildConfig: Release
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_coreclr.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_runtimetests.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_tools_illink.containsChange'], true),
                eq(variables['isRollingBuild'], true))

      #
      # CoreCLR NativeAOT release build and libraries tests
      # Only when CoreCLR or library is changed
      #
      - template: /eng/pipelines/common/platform-matrix.yml
        parameters:
          jobTemplate: /eng/pipelines/common/global-build-job.yml
          helixQueuesTemplate: /eng/pipelines/libraries/helix-queues-setup.yml
          buildConfig: Release
          platforms:
          - windows_arm64
          - linux_arm64
          - osx_arm64
          jobParameters:
            testGroup: innerloop
            isSingleFile: true
            nameSuffix: NativeAOT_Libraries
            buildArgs: -s clr.aot+host.native+libs+libs.tests -c $(_BuildConfig) /p:TestNativeAot=true /p:RunSmokeTestsOnly=true /p:ArchiveTests=true /p:RunAnalyzers=false
            timeoutInMinutes: 240 # Doesn't actually take long, but we've seen the ARM64 Helix queue often get backlogged for 2+ hours
            # extra steps, run tests
            postBuildSteps:
              - template: /eng/pipelines/libraries/helix.yml
                parameters:
                  creator: dotnet-bot
                  testRunNamePrefixSuffix: NativeAOT_$(_BuildConfig)
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_libraries.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_coreclr.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_tools_illink.containsChange'], true),
                eq(variables['isRollingBuild'], true))

      # Build and test clr tools
      - template: /eng/pipelines/common/platform-matrix.yml
        parameters:
          jobTemplate: /eng/pipelines/common/global-build-job.yml
          buildConfig: checked
          platforms:
          - linux_x64
          jobParameters:
            timeoutInMinutes: 120
            nameSuffix: CLR_Tools_Tests
            buildArgs: -s clr.aot+clr.iltools+libs.sfx+clr.toolstests -c $(_BuildConfig) -test
            enablePublishTestResults: true
            testResultsFormat: 'xunit'
            # We want to run AOT tests when illink changes because there's share code and tests from illink which are used by AOT
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_coreclr.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_tools_illink.containsChange'], true),
                eq(variables['isRollingBuild'], true))
      #
      # Build CrossDacs
      #
      - template: /eng/pipelines/common/platform-matrix.yml
        parameters:
          jobTemplate: /eng/pipelines/common/global-build-job.yml
          buildConfig: release
          platforms:
          - windows_x64
          variables:
            - name: _archParameter
              value: -arch x64,x86,arm,arm64
          jobParameters:
            buildArgs: -s linuxdac+alpinedac -c Checked,$(_BuildConfig)
            nameSuffix: CrossDac
            isOfficialBuild: false
            timeoutInMinutes: 60
            postBuildSteps:
            - publish: $(Build.SourcesDirectory)/artifacts/bin/coreclr
              displayName: Publish CrossDacs for diagnostics
              artifact: CoreCLRCrossDacArtifacts
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_non_mono_and_wasm.containsChange'], true),
                eq(variables['isRollingBuild'], true))

      # Build Mono AOT offset headers once, for consumption elsewhere
      # Only when mono changed
      #
      - template: /eng/pipelines/common/platform-matrix.yml
        parameters:
          jobTemplate: /eng/pipelines/mono/templates/generate-offsets.yml
          buildConfig: release
          platforms:
          - android_x64
          - browser_wasm
          - wasi_wasm
          - tvos_arm64
          - ios_arm64
          - maccatalyst_x64
          jobParameters:
            isOfficialBuild: false
            # needed by crossaot
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_mono_excluding_wasm.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_installer.containsChange'], true),
                eq(variables['isRollingBuild'], true))

      # Build the whole product using Mono runtime
      # Only when libraries, mono or installer are changed
      #
      - template: /eng/pipelines/common/platform-matrix.yml
        parameters:
          jobTemplate: /eng/pipelines/common/global-build-job.yml
          buildConfig: ${{ variables.debugOnPrReleaseOnRolling }}
          runtimeFlavor: mono
          platforms:
          - tvossimulator_x64
          - linux_arm
          jobParameters:
            testGroup: innerloop
            nameSuffix: AllSubsets_Mono
            buildArgs: -s mono+libs+host+packs -c $(_BuildConfig)
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_libraries.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_mono_excluding_wasm.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_installer.containsChange'], true),
                eq(variables['isRollingBuild'], true))

      - template: /eng/pipelines/common/platform-matrix.yml
        parameters:
          jobTemplate: /eng/pipelines/common/global-build-job.yml
          buildConfig: Release
          runtimeFlavor: mono
          platforms:
          - linux_musl_x64
          - linux_riscv64
          jobParameters:
            testGroup: innerloop
            nameSuffix: AllSubsets_Mono
            buildArgs: -s mono+libs+host+packs -c $(_BuildConfig)
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_libraries.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_mono_excluding_wasm.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_installer.containsChange'], true),
                eq(variables['isRollingBuild'], true))

      #
      # WebAssembly legs
      #
      - template: /eng/pipelines/common/templates/wasm-library-tests.yml
        parameters:
          platforms:
            - browser_wasm
          alwaysRun: ${{ variables.isRollingBuild }}
          extraBuildArgs: /p:AotHostArchitecture=x64 /p:AotHostOS=$(_hostedOS)
          scenarios:
            - normal
            - WasmTestOnBrowser

      - template: /eng/pipelines/common/templates/wasm-library-tests.yml
        parameters:
          platforms:
            - browser_wasm_win
          alwaysRun: ${{ variables.isRollingBuild }}
          extraBuildArgs: /p:AotHostArchitecture=x64 /p:AotHostOS=$(_hostedOS)
          scenarios:
            - WasmTestOnBrowser

      # Library tests with full threading
      - template: /eng/pipelines/common/templates/wasm-library-tests.yml
        parameters:
          platforms:
            - browser_wasm
            #- browser_wasm_win
          nameSuffix: _Threading
          extraBuildArgs: /p:WasmEnableThreads=true /p:AotHostArchitecture=x64 /p:AotHostOS=$(_hostedOS)
          alwaysRun: ${{ variables.isRollingBuild }}
          shouldRunSmokeOnly: onLibrariesAndIllinkChanges
          scenarios:
            - WasmTestOnBrowser
            #- WasmTestOnNodeJS - this is not supported yet, https://github.com/dotnet/runtime/issues/85592

      # EAT Library tests - only run on linux
      - template: /eng/pipelines/common/templates/wasm-library-aot-tests.yml
        parameters:
          platforms:
            - browser_wasm
          nameSuffix: _EAT
          runAOT: false
          shouldRunSmokeOnly: false
          alwaysRun: ${{ variables.isRollingBuild }}
          extraBuildArgs: /p:AotHostArchitecture=x64 /p:AotHostOS=$(_hostedOS) /maxcpucount:2

      # AOT Library tests
      - template: /eng/pipelines/common/templates/wasm-library-aot-tests.yml
        parameters:
          platforms:
            - browser_wasm
            - browser_wasm_win
            - wasi_wasm
            - wasi_wasm_win
          nameSuffix: _Smoke_AOT
          runAOT: true
          shouldRunSmokeOnly: true
          alwaysRun: ${{ variables.isRollingBuild }}
          extraBuildArgs: /p:AotHostArchitecture=x64 /p:AotHostOS=$(_hostedOS)

      # For Wasm.Build.Tests - runtime pack builds
      - template: /eng/pipelines/common/templates/wasm-build-only.yml
        parameters:
          platforms:
            - browser_wasm
            - browser_wasm_win
          condition: or(eq(variables.isRollingBuild, true), eq(variables.wasmSingleThreadedBuildOnlyNeededOnDefaultPipeline, true))
          nameSuffix: SingleThreaded
          extraBuildArgs: /p:AotHostArchitecture=x64 /p:AotHostOS=$(_hostedOS)
          publishArtifactsForWorkload: true
          publishWBT: true

      - template: /eng/pipelines/common/templates/wasm-build-only.yml
        parameters:
          platforms:
            - browser_wasm
            - browser_wasm_win
          condition: or(eq(variables.isRollingBuild, true), eq(variables.wasmSingleThreadedBuildOnlyNeededOnDefaultPipeline, true))
          nameSuffix: MultiThreaded
          extraBuildArgs: /p:WasmEnableThreads=true /p:AotHostArchitecture=x64 /p:AotHostOS=$(_hostedOS)
          publishArtifactsForWorkload: true
          publishWBT: false

      # Browser Wasm.Build.Tests
      - template: /eng/pipelines/common/templates/browser-wasm-build-tests.yml
        parameters:
          platforms:
            - browser_wasm
            - browser_wasm_win
          alwaysRun: ${{ variables.isRollingBuild }}
          extraBuildArgs: /p:AotHostArchitecture=x64 /p:AotHostOS=$(_hostedOS)

      # Wasm Debugger tests
      - template: /eng/pipelines/common/templates/wasm-debugger-tests.yml
        parameters:
          platforms:
            - browser_wasm
            - browser_wasm_win
          alwaysRun: ${{ variables.isRollingBuild }}
          extraBuildArgs: /p:AotHostArchitecture=x64 /p:AotHostOS=$(_hostedOS)

      # Wasm runtime tests
      - template: /eng/pipelines/common/templates/wasm-runtime-tests.yml
        parameters:
          platforms:
            - browser_wasm
          alwaysRun: ${{ variables.isRollingBuild }}
          extraBuildArgs: /p:AotHostArchitecture=x64 /p:AotHostOS=$(_hostedOS)

      # WASI/WASM

      - template: /eng/pipelines/common/templates/wasm-library-tests.yml
        parameters:
          platforms:
            - wasi_wasm
            - wasi_wasm_win
          nameSuffix: '_Smoke'
          extraBuildArgs: /p:EnableAggressiveTrimming=true /p:RunWasmSamples=true /p:AotHostArchitecture=x64 /p:AotHostOS=$(_hostedOS)
          shouldRunSmokeOnly: true
          alwaysRun: ${{ variables.isRollingBuild }}
          scenarios:
            - normal

      - template: /eng/pipelines/common/templates/simple-wasm-build-tests.yml
        parameters:
          platforms:
            - wasi_wasm
            - wasi_wasm_win
          extraBuildArgs: /p:AotHostArchitecture=x64 /p:AotHostOS=$(_hostedOS)
          alwaysRun: ${{ variables.isRollingBuild }}

      #
      # Android devices
      # Build the whole product using Mono and run libraries tests
      #
      - template: /eng/pipelines/common/platform-matrix.yml
        parameters:
          jobTemplate: /eng/pipelines/common/global-build-job.yml
          helixQueuesTemplate: /eng/pipelines/libraries/helix-queues-setup.yml
          buildConfig: Release
          runtimeFlavor: mono
          platforms:
          - android_arm
          - android_arm64
          variables:
            # map dependencies variables to local variables
            - name: librariesContainsChange
              value: $[ stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_libraries.containsChange'] ]
            - name: monoContainsChange
              value: $[ stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_mono_excluding_wasm.containsChange'] ]
          jobParameters:
            testGroup: innerloop
            nameSuffix: AllSubsets_Mono
            buildArgs: -s mono+libs+libs.tests+host+packs -c $(_BuildConfig) /p:ArchiveTests=true /p:RunSmokeTestsOnly=true /p:EnableAdditionalTimezoneChecks=true
            timeoutInMinutes: 480
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_libraries.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_mono_excluding_wasm.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_installer.containsChange'], true),
                eq(variables['isRollingBuild'], true))
            # extra steps, run tests
            postBuildSteps:
              - template: /eng/pipelines/libraries/helix.yml
                parameters:
                  creator: dotnet-bot
                  testRunNamePrefixSuffix: Mono_$(_BuildConfig)
                  condition: >-
                    or(
                    eq(variables['librariesContainsChange'], true),
                    eq(variables['monoContainsChange'], true),
                    eq(variables['isRollingBuild'], true))

      #
      # iOS/tvOS devices - Full AOT + AggressiveTrimming to reduce size
      # Build the whole product using Mono and run libraries tests
      #
      - template: /eng/pipelines/common/platform-matrix.yml
        parameters:
          jobTemplate: /eng/pipelines/common/global-build-job.yml
          helixQueuesTemplate: /eng/pipelines/libraries/helix-queues-setup.yml
          buildConfig: Release
          runtimeFlavor: mono
          platforms:
            - ios_arm64
            - tvos_arm64
          variables:
            # map dependencies variables to local variables
            - name: librariesContainsChange
              value: $[ stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_libraries.containsChange'] ]
            - name: monoContainsChange
              value: $[ stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_mono_excluding_wasm.containsChange'] ]
          jobParameters:
            testGroup: innerloop
            nameSuffix: AllSubsets_Mono
            buildArgs: -s mono+libs+libs.tests+host+packs -c $(_BuildConfig) /p:ArchiveTests=true /p:DevTeamProvisioning=- /p:RunAOTCompilation=true /p:RunSmokeTestsOnly=true /p:BuildTestsOnHelix=true /p:EnableAdditionalTimezoneChecks=true /p:UsePortableRuntimePack=true /p:BuildDarwinFrameworks=true
            timeoutInMinutes: 480
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_libraries.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_mono_excluding_wasm.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_installer.containsChange'], true),
                eq(variables['isRollingBuild'], true))
            # extra steps, run tests
            postBuildSteps:
              - template: /eng/pipelines/libraries/helix.yml
                parameters:
                  creator: dotnet-bot
                  testRunNamePrefixSuffix: Mono_$(_BuildConfig)
                  extraHelixArguments: /p:NeedsToBuildAppsOnHelix=true
                  condition: >-
                    or(
                    eq(variables['librariesContainsChange'], true),
                    eq(variables['monoContainsChange'], true),
                    eq(variables['isRollingBuild'], true))

      #
      # iOS/tvOS devices
      # Build the whole product using Native AOT and run libraries tests
      #
      - template: /eng/pipelines/common/platform-matrix.yml
        parameters:
          jobTemplate: /eng/pipelines/common/global-build-job.yml
          helixQueuesTemplate: /eng/pipelines/libraries/helix-queues-setup.yml
          buildConfig: Release
          runtimeFlavor: coreclr
          platforms:
            - ios_arm64
            - tvos_arm64
          variables:
            # map dependencies variables to local variables
            - name: librariesContainsChange
              value: $[ stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_libraries.containsChange'] ]
            - name: coreclrContainsChange
              value: $[ stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_coreclr.containsChange'] ]
          jobParameters:
            testGroup: innerloop
            nameSuffix: AllSubsets_NativeAOT
            buildArgs: --cross -s clr.alljits+clr.tools+clr.nativeaotruntime+clr.nativeaotlibs+libs+libs.tests -c $(_BuildConfig) /p:ArchiveTests=true /p:RunSmokeTestsOnly=true /p:DevTeamProvisioning=- /p:BuildTestsOnHelix=true /p:UseNativeAOTRuntime=true /p:RunAOTCompilation=false /p:ContinuousIntegrationBuild=true
            timeoutInMinutes: 180
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_libraries.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_coreclr.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_installer.containsChange'], true),
                eq(variables['isRollingBuild'], true))
            # extra steps, run tests
            postBuildSteps:
              - template: /eng/pipelines/libraries/helix.yml
                parameters:
                  creator: dotnet-bot
                  testRunNamePrefixSuffix: NativeAOT_$(_BuildConfig)
                  extraHelixArguments: /p:NeedsToBuildAppsOnHelix=true
                  condition: >-
                    or(
                    eq(variables['librariesContainsChange'], true),
                    eq(variables['coreclrContainsChange'], true),
                    eq(variables['isRollingBuild'], true))

      #
      # MacCatalyst interp - requires AOT Compilation and Interp flags
      # Build the whole product using Mono and run libraries tests
      #
      - template: /eng/pipelines/common/platform-matrix.yml
        parameters:
          jobTemplate: /eng/pipelines/common/global-build-job.yml
          helixQueuesTemplate: /eng/pipelines/libraries/helix-queues-setup.yml
          buildConfig: Release
          runtimeFlavor: mono
          platforms:
          - maccatalyst_x64
          - ${{ if eq(variables['isRollingBuild'], true) }}:
            - maccatalyst_arm64
          variables:
            # map dependencies variables to local variables
            - name: librariesContainsChange
              value: $[ stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_libraries.containsChange'] ]
            - name: monoContainsChange
              value: $[ stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_mono_excluding_wasm.containsChange'] ]
          jobParameters:
            testGroup: innerloop
            nameSuffix: AllSubsets_Mono
            buildArgs: -s mono+libs+host+packs+libs.tests -c $(_BuildConfig) /p:ArchiveTests=true /p:RunSmokeTestsOnly=true /p:DevTeamProvisioning=adhoc /p:RunAOTCompilation=true /p:MonoForceInterpreter=true /p:BuildDarwinFrameworks=true
            timeoutInMinutes: 180
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_libraries.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_mono_excluding_wasm.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_installer.containsChange'], true),
                eq(variables['isRollingBuild'], true))
            # extra steps, run tests
            postBuildSteps:
              - template: /eng/pipelines/libraries/helix.yml
                parameters:
                  creator: dotnet-bot
                  testRunNamePrefixSuffix: Mono_$(_BuildConfig)
                  condition: >-
                    or(
                      eq(variables['librariesContainsChange'], true),
                      eq(variables['monoContainsChange'], true),
                      eq(variables['isRollingBuild'], true))

      #
      # Build Mono and Installer on LLVMJIT mode
      #
      - template: /eng/pipelines/common/platform-matrix.yml
        parameters:
          jobTemplate: /eng/pipelines/common/global-build-job.yml
          buildConfig: Release
          runtimeFlavor: mono
          platforms:
          - osx_x64
          jobParameters:
            testGroup: innerloop
            nameSuffix: AllSubsets_Mono_LLVMJIT
            buildArgs: -s mono+libs+host+packs -c $(_BuildConfig)
                      /p:MonoEnableLLVM=true /p:MonoBundleLLVMOptimizer=false
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_libraries.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_mono_excluding_wasm.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_installer.containsChange'], true),
                eq(variables['isRollingBuild'], true))

      - template: /eng/pipelines/common/platform-matrix.yml
        parameters:
          jobTemplate: /eng/pipelines/common/global-build-job.yml
          buildConfig: ${{ variables.debugOnPrReleaseOnRolling }}
          runtimeFlavor: mono
          platforms:
          - linux_x64
          - linux_arm64
          jobParameters:
            testGroup: innerloop
            nameSuffix: AllSubsets_Mono_LLVMJIT
            buildArgs: -s mono+libs+host+packs -c $(_BuildConfig)
                      /p:MonoEnableLLVM=true /p:MonoBundleLLVMOptimizer=false
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_libraries.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_mono_excluding_wasm.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_installer.containsChange'], true),
                eq(variables['isRollingBuild'], true))

      #
      # Build Mono and Installer on LLVMAOT mode
      #
      - template: /eng/pipelines/common/platform-matrix.yml
        parameters:
          jobTemplate: /eng/pipelines/common/global-build-job.yml
          buildConfig: Release
          runtimeFlavor: mono
          platforms:
          - linux_x64
          - linux_arm64
          jobParameters:
            testGroup: innerloop
            nameSuffix: AllSubsets_Mono_LLVMAOT
            buildArgs: -s mono+libs+host+packs -c $(_BuildConfig)
                      /p:MonoEnableLLVM=true /p:MonoAOTEnableLLVM=true /p:MonoBundleLLVMOptimizer=true
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_libraries.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_mono_excluding_wasm.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_installer.containsChange'], true),
                eq(variables['isRollingBuild'], true))

      - template: /eng/pipelines/common/platform-matrix.yml
        parameters:
          jobTemplate: /eng/pipelines/common/global-build-job.yml
          buildConfig: ${{ variables.debugOnPrReleaseOnRolling }}
          runtimeFlavor: mono
          platforms:
          - osx_x64
          jobParameters:
            testGroup: innerloop
            nameSuffix: AllSubsets_Mono_LLVMAOT
            buildArgs: -s mono+libs+host+packs -c $(_BuildConfig)
                      /p:MonoEnableLLVM=true /p:MonoAOTEnableLLVM=true /p:MonoBundleLLVMOptimizer=true
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_libraries.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_mono_excluding_wasm.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_installer.containsChange'], true),
                eq(variables['isRollingBuild'], true))

      #
      # Build Mono debug
      # Only when mono changed
      #
      - template: /eng/pipelines/common/platform-matrix.yml
        parameters:
          jobTemplate: /eng/pipelines/common/global-build-job.yml
          runtimeFlavor: mono
          buildConfig: debug
          platforms:
          - osx_x64
          - osx_arm64
          - linux_x64
          - linux_arm64
          # - linux_musl_arm64
          - windows_x64
          - windows_x86
          # - windows_arm64
          jobParameters:
            nameSuffix: Mono_Runtime
            buildArgs: -s mono -c $(_BuildConfig)
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_mono_excluding_wasm.containsChange'], true),
                eq(variables['isRollingBuild'], true))

      #
      # Build Mono release AOT cross-compilers
      #
      - template: /eng/pipelines/common/platform-matrix.yml
        parameters:
          jobTemplate: /eng/pipelines/common/global-build-job.yml
          runtimeFlavor: mono
          buildConfig: release
          platforms:
          - linux_x64
          - linux_musl_x64
          - linux_arm64
          - linux_musl_arm64
          jobParameters:
            buildArgs: -s mono+packs -c $(_BuildConfig)
                      /p:MonoCrossAOTTargetOS=android+browser+wasi /p:SkipMonoCrossJitConfigure=true /p:BuildMonoAOTCrossCompilerOnly=true
            nameSuffix: CrossAOT_Mono
            runtimeVariant: crossaot
            dependsOn:
            - mono_android_offsets
            - mono_browser_offsets
            - mono_wasi_offsets
            monoCrossAOTTargetOS:
            - android
            - browser
            - wasi
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_mono_excluding_wasm.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_installer.containsChange'], true),
                eq(variables['isRollingBuild'], true))

      - template: /eng/pipelines/common/platform-matrix.yml
        parameters:
          jobTemplate: /eng/pipelines/common/global-build-job.yml
          runtimeFlavor: mono
          buildConfig: release
          platforms:
          - windows_arm64
          - windows_x64
          jobParameters:
            buildArgs: -s mono+packs -c $(_BuildConfig)
                      /p:MonoCrossAOTTargetOS=android+browser+wasi /p:SkipMonoCrossJitConfigure=true /p:BuildMonoAOTCrossCompilerOnly=true
            nameSuffix: CrossAOT_Mono
            runtimeVariant: crossaot
            dependsOn:
            - mono_android_offsets
            - mono_browser_offsets
            - mono_wasi_offsets
            monoCrossAOTTargetOS:
            - android
            - browser
            - wasi
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_mono_excluding_wasm.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_installer.containsChange'], true),
                eq(variables['isRollingBuild'], true))
      #
      # Build Mono release AOT cross-compilers
      # Only when mono changed
      #

      - template: /eng/pipelines/common/platform-matrix.yml
        parameters:
          jobTemplate: /eng/pipelines/common/global-build-job.yml
          runtimeFlavor: mono
          buildConfig: release
          platforms:
          - osx_x64
          - osx_arm64
          jobParameters:
            buildArgs: -s mono+packs -c $(_BuildConfig)
                      /p:MonoCrossAOTTargetOS=android+browser+wasi+tvos+ios+maccatalyst /p:SkipMonoCrossJitConfigure=true /p:BuildMonoAOTCrossCompilerOnly=true
            nameSuffix: CrossAOT_Mono
            runtimeVariant: crossaot
            dependsOn:
            - mono_android_offsets
            - mono_browser_offsets
            - mono_wasi_offsets
            - mono_tvos_offsets
            - mono_ios_offsets
            - mono_maccatalyst_offsets
            monoCrossAOTTargetOS:
            - android
            - browser
            - wasi
            - tvos
            - ios
            - maccatalyst
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_mono.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_installer.containsChange'], true),
                eq(variables['isRollingBuild'], true))

      #
      # Build and test libraries for .NET Framework
      #
      - template: /eng/pipelines/common/platform-matrix.yml
        parameters:
          jobTemplate: /eng/pipelines/common/global-build-job.yml
          buildConfig: Release
          platforms:
          - windows_x86
          helixQueuesTemplate: /eng/pipelines/libraries/helix-queues-setup.yml
          jobParameters:
            framework: net48
            buildArgs: -s tools+libs+libs.tests -framework net48 -c $(_BuildConfig) -testscope innerloop /p:ArchiveTests=true
            nameSuffix: Libraries_NET48
            timeoutInMinutes: 150
            postBuildSteps:
              - template: /eng/pipelines/libraries/helix.yml
                parameters:
                  creator: dotnet-bot
                  testRunNamePrefixSuffix: NET48_$(_BuildConfig)
                  extraHelixArguments: /p:BuildTargetFramework=net48
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_libraries.containsChange'], true),
                eq(variables['isRollingBuild'], true))

      #
      # Build and test libraries AllConfigurations
      #
      - template: /eng/pipelines/common/platform-matrix.yml
        parameters:
          jobTemplate: /eng/pipelines/common/global-build-job.yml
          buildConfig: ${{ variables.debugOnPrReleaseOnRolling }}
          platforms:
          - windows_x64
          jobParameters:
            buildArgs: -test -s tools+libs+libs.tests -allConfigurations -c $(_BuildConfig) /p:TestAssemblies=false /p:TestPackages=true
            nameSuffix: Libraries_AllConfigurations
            timeoutInMinutes: 150
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_libraries.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_tools_illink.containsChange'], true),
                eq(variables['isRollingBuild'], true))

      #
      # Installer Build and Test
      # These are always built since they only take like 15 minutes
      # we expect these to be done before we finish libraries or coreclr testing.
      #
      - template: /eng/pipelines/common/platform-matrix.yml
        parameters:
          jobTemplate: /eng/pipelines/installer/jobs/build-job.yml
          buildConfig: ${{ variables.debugOnPrReleaseOnRolling }}
          platforms:
            - windows_x86
          jobParameters:
            liveRuntimeBuildConfig: release
            liveLibrariesBuildConfig: Release
            unifiedArtifactsName: CoreCLR_Libraries_BuildArtifacts_$(osGroup)$(osSubgroup)_$(archType)_Release
            unifiedBuildConfigOverride: release
            unifiedBuildNameSuffix: CoreCLR_Libraries
            condition:
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_non_mono_and_wasm.containsChange'], true),
                eq(variables['isRollingBuild'], true))

      - template: /eng/pipelines/common/platform-matrix.yml
        parameters:
          jobTemplate: /eng/pipelines/installer/jobs/build-job.yml
          buildConfig: Release
          platforms:
            - osx_x64
            - linux_x64
            - windows_x64
          jobParameters:
            liveRuntimeBuildConfig: release
            liveLibrariesBuildConfig: ${{ variables.debugOnPrReleaseOnRolling }}
            unifiedArtifactsName: CoreCLR_Libraries_BuildArtifacts_$(osGroup)$(osSubgroup)_$(archType)_$(debugOnPrReleaseOnRolling)
            unifiedBuildConfigOverride: ${{ variables.debugOnPrReleaseOnRolling }}
            unifiedBuildNameSuffix: CoreCLR_Libraries
            condition:
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_non_mono_and_wasm.containsChange'], true),
                eq(variables['isRollingBuild'], true))

      #
      # Build the whole product using Mono and run runtime tests
      #
      - template: /eng/pipelines/common/platform-matrix.yml
        parameters:
          jobTemplate: /eng/pipelines/common/global-build-job.yml
          helixQueuesTemplate: /eng/pipelines/coreclr/templates/helix-queues-setup.yml
          buildConfig: Release
          runtimeFlavor: mono
          platforms:
            - osx_x64
            - linux_arm64
          variables:
            - name: timeoutPerTestInMinutes
              value: 60
            - name: timeoutPerTestCollectionInMinutes
              value: 180
          jobParameters:
            testGroup: innerloop
            nameSuffix: AllSubsets_Mono_Minijit_RuntimeTests
            runtimeVariant: minijit
            buildArgs: -s mono+libs+clr.hosts+clr.iltools -c Release
            timeoutInMinutes: 180
            condition: >-
                  or(
                    eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_mono_excluding_wasm.containsChange'], true),
                    eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_runtimetests.containsChange'], true),
                    eq(variables['isRollingBuild'], true))

            postBuildSteps:
              - template: /eng/pipelines/common/templates/runtimes/build-runtime-tests-and-send-to-helix.yml
                parameters:
                  creator: dotnet-bot
                  testRunNamePrefixSuffix: Mono_Release
            extraVariablesTemplates:
              - template: /eng/pipelines/common/templates/runtimes/test-variables.yml

      #
      # Build the whole product using Mono and run runtime tests
      #
      - template: /eng/pipelines/common/platform-matrix.yml
        parameters:
          jobTemplate: /eng/pipelines/common/global-build-job.yml
          helixQueuesTemplate: /eng/pipelines/coreclr/templates/helix-queues-setup.yml
          buildConfig: Release
          runtimeFlavor: mono
          platforms:
            - windows_x64
          variables:
            - name: timeoutPerTestInMinutes
              value: 60
            - name: timeoutPerTestCollectionInMinutes
              value: 180
          jobParameters:
            testGroup: innerloop
            nameSuffix: AllSubsets_Mono_Minijit_RuntimeTests
            runtimeVariant: minijit
            buildArgs: -s mono+libs+clr.hosts+clr.iltools -c Release -lc ${{ variables.debugOnPrReleaseOnRolling }}
            timeoutInMinutes: 180
            condition: >-
                  or(
                    eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_mono_excluding_wasm.containsChange'], true),
                    eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_runtimetests.containsChange'], true),
                    eq(variables['isRollingBuild'], true))

            postBuildSteps:
              - template: /eng/pipelines/common/templates/runtimes/build-runtime-tests-and-send-to-helix.yml
                parameters:
                  creator: dotnet-bot
                  testRunNamePrefixSuffix: Mono_Release
            extraVariablesTemplates:
              - template: /eng/pipelines/common/templates/runtimes/test-variables.yml
                parameters:
                  liveLibrariesBuildConfig: ${{ variables.debugOnPrReleaseOnRolling }}

      #
      # Mono CoreCLR runtime Test executions using live libraries in interpreter mode
      # Only when Mono is changed

      - template: /eng/pipelines/common/platform-matrix.yml
        parameters:
          jobTemplate: /eng/pipelines/common/global-build-job.yml
          helixQueuesTemplate: /eng/pipelines/coreclr/templates/helix-queues-setup.yml
          buildConfig: Release
          runtimeFlavor: mono
          platforms:
            - osx_x64
          variables:
            - name: timeoutPerTestInMinutes
              value: 60
            - name: timeoutPerTestCollectionInMinutes
              value: 180
          jobParameters:
            testGroup: innerloop
            nameSuffix: AllSubsets_Mono_Interpreter_RuntimeTests
            runtimeVariant: monointerpreter
            buildArgs: -s mono+libs+clr.hosts+clr.iltools -c Release
            timeoutInMinutes: 180
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_mono_excluding_wasm.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_runtimetests.containsChange'], true),
                eq(variables['isRollingBuild'], true))
            postBuildSteps:
              - template: /eng/pipelines/common/templates/runtimes/build-runtime-tests-and-send-to-helix.yml
                parameters:
                  creator: dotnet-bot
                  testRunNamePrefixSuffix: Mono_Release
            extraVariablesTemplates:
              - template: /eng/pipelines/common/templates/runtimes/test-variables.yml
      #
      # Mono CoreCLR runtime Test executions using live libraries and LLVM AOT
      # Only when Mono is changed
      #
      - template: /eng/pipelines/common/platform-matrix.yml
        parameters:
          jobTemplate: /eng/pipelines/common/global-build-job.yml
          helixQueuesTemplate: /eng/pipelines/coreclr/templates/helix-queues-setup.yml
          buildConfig: Release
          runtimeFlavor: mono
          platforms:
            - linux_x64
            # Disabled pending outcome of https://github.com/dotnet/runtime/issues/60234 investigation
            #- linux_arm64
          variables:
            - name: timeoutPerTestInMinutes
              value: 60
            - name: timeoutPerTestCollectionInMinutes
              value: 180
          jobParameters:
            testGroup: innerloop
            nameSuffix: AllSubsets_Mono_LLVMAot_RuntimeTests
            runtimeVariant: llvmaot
            buildArgs: -s mono+libs+clr.hosts+clr.iltools -c Release /p:MonoEnableLLVM=true /p:MonoAOTEnableLLVM=true /p:MonoBundleLLVMOptimizer=true
            timeoutInMinutes: 180

            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_mono_excluding_wasm.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_runtimetests.containsChange'], true),
                eq(variables['isRollingBuild'], true))
            postBuildSteps:
              - template: /eng/pipelines/common/templates/runtimes/build-runtime-tests-and-send-to-helix.yml
                parameters:
                  creator: dotnet-bot
                  llvmAotStepContainer: linux_x64_llvmaot
                  testRunNamePrefixSuffix: Mono_Release
            extraVariablesTemplates:
              - template: /eng/pipelines/common/templates/runtimes/test-variables.yml

      #
      # CoreCLR Test builds using live libraries release build
      # Only when CoreCLR is changed
      #
      - template: /eng/pipelines/common/platform-matrix.yml
        parameters:
          jobTemplate: /eng/pipelines/common/templates/runtimes/build-test-job.yml
          buildConfig: checked
          platforms:
          - CoreClrTestBuildHost # Either osx_x64 or linux_x64
          jobParameters:
            testGroup: innerloop
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_coreclr.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_runtimetests.containsChange'], true),
                eq(variables['isRollingBuild'], true))

      #
      # CoreCLR Test executions using live libraries
      # Only when CoreCLR is changed
      #
      - template: /eng/pipelines/common/platform-matrix.yml
        parameters:
          jobTemplate: /eng/pipelines/common/templates/runtimes/run-test-job.yml
          buildConfig: checked
          platforms:
          - linux_arm
          - windows_x86
          - windows_arm64
          helixQueueGroup: pr
          helixQueuesTemplate: /eng/pipelines/coreclr/templates/helix-queues-setup.yml
          jobParameters:
            testGroup: innerloop
            liveLibrariesBuildConfig: Release
            unifiedArtifactsName: CoreCLR_ReleaseLibraries_BuildArtifacts_$(osGroup)$(osSubgroup)_$(archType)_$(_BuildConfig)
            unifiedBuildNameSuffix: CoreCLR_ReleaseLibraries
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_coreclr.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_runtimetests.containsChange'], true),
                eq(variables['isRollingBuild'], true))

      - template: /eng/pipelines/common/platform-matrix.yml
        parameters:
          jobTemplate: /eng/pipelines/common/templates/runtimes/run-test-job.yml
          buildConfig: checked
          platforms:
          - osx_x64
          - linux_x64
          - linux_arm64
          - windows_x64
          helixQueueGroup: pr
          helixQueuesTemplate: /eng/pipelines/coreclr/templates/helix-queues-setup.yml
          jobParameters:
            testGroup: innerloop
            liveLibrariesBuildConfig: ${{ variables.debugOnPrReleaseOnRolling }}
            unifiedArtifactsName: Libraries_CheckedCoreCLR_BuildArtifacts_$(osGroup)$(osSubgroup)_$(archType)_$(debugOnPrReleaseOnRolling)
            unifiedBuildNameSuffix: Libraries_CheckedCoreCLR
            unifiedBuildConfigOverride: ${{ variables.debugOnPrReleaseOnRolling }}
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_coreclr.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_runtimetests.containsChange'], true),
                eq(variables['isRollingBuild'], true))

      - template: /eng/pipelines/common/platform-matrix.yml
        parameters:
          jobTemplate: /eng/pipelines/common/templates/runtimes/run-test-job.yml
          buildConfig: checked
          platforms:
          - osx_arm64
          helixQueueGroup: pr
          helixQueuesTemplate: /eng/pipelines/coreclr/templates/helix-queues-setup.yml
          jobParameters:
            testGroup: innerloop
            liveLibrariesBuildConfig: ${{ variables.debugOnPrReleaseOnRolling }}
            unifiedArtifactsName: Libraries_CheckedCoreCLR_BuildArtifacts_$(osGroup)$(osSubgroup)_$(archType)_$(debugOnPrReleaseOnRolling)
            unifiedBuildNameSuffix: Libraries_CheckedCoreCLR
            unifiedBuildConfigOverride: ${{ variables.debugOnPrReleaseOnRolling }}
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_coreclr_AppleSilicon.containsChange'], true),
                eq(variables['isRollingBuild'], true))

      #
      # Libraries Release Test Execution against a release coreclr runtime
      # Only when the PR contains a libraries change
      #
      - template: /eng/pipelines/common/platform-matrix.yml
        parameters:
          jobTemplate: /eng/pipelines/libraries/run-test-job.yml
          buildConfig: Release
          platforms:
          - windows_x86
          helixQueuesTemplate: /eng/pipelines/libraries/helix-queues-setup.yml
          jobParameters:
            isOfficialBuild: false
            testScope: innerloop
            liveRuntimeBuildConfig: release
            unifiedArtifactsName: CoreCLR_Libraries_BuildArtifacts_$(osGroup)$(osSubgroup)_$(archType)_$(_BuildConfig)
            helixArtifactsName: CoreCLR_Libraries_TestArtifacts_$(osGroup)$(osSubgroup)_$(archType)_$(_BuildConfig)
            unifiedBuildNameSuffix: CoreCLR_Libraries
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_libraries.containsChange'], true),
                eq(variables['isRollingBuild'], true))

      #
      # Libraries Debug Test Execution against a release coreclr runtime
      # Only when the PR contains a libraries change
      #
      - template: /eng/pipelines/common/platform-matrix.yml
        parameters:
          jobTemplate: /eng/pipelines/libraries/run-test-job.yml
          buildConfig: ${{ variables.debugOnPrReleaseOnRolling }}
          platforms:
          - windows_x64
          - osx_x64
          - linux_x64
          - linux_musl_x64
          helixQueuesTemplate: /eng/pipelines/libraries/helix-queues-setup.yml
          jobParameters:
            isOfficialBuild: false
            testScope: innerloop
            liveRuntimeBuildConfig: release
            unifiedArtifactsName: CoreCLR_Libraries_BuildArtifacts_$(osGroup)$(osSubgroup)_$(archType)_$(debugOnPrReleaseOnRolling)
            helixArtifactsName: CoreCLR_Libraries_TestArtifacts_$(osGroup)$(osSubgroup)_$(archType)_$(debugOnPrReleaseOnRolling)
            unifiedBuildNameSuffix: CoreCLR_Libraries
            unifiedBuildConfigOverride: ${{ variables.debugOnPrReleaseOnRolling }}
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_libraries.containsChange'], true),
                eq(variables['isRollingBuild'], true))
      # The next three jobs run checked coreclr + <either debug or release in PR> libraries tests.
      # The matrix looks like the following, where the right columns specify which configurations
      # the libraries tests are built in.
      # ________________________________________
      # | Platform         | PR      | Rolling |
      # | ---------------- | ------- | ------- |
      # | linux-arm64      | Debug   | Release |
      # | windows-x86      | Debug   | Release |
      # | linux-musl-x64   | Debug   | Release |
      # | OSX-x64          | Debug   | Release |
      # | linux-musl-arm   | Release | Release |
      # | linux-musl-arm64 | Release | Release |
      # | linux-x64        | Release | Release |
      # | windows-x64      | Release | Release |

      #
      # Debug (PR) / Release (rolling) Libraries Test Execution against a checked runtime
      # Only when the PR contains a coreclr change
      #
      - template: /eng/pipelines/common/platform-matrix.yml
        parameters:
          jobTemplate: /eng/pipelines/libraries/run-test-job.yml
          buildConfig: ${{ variables.debugOnPrReleaseOnRolling }}
          platforms:
          - linux_arm64
          - windows_x86
          - linux_musl_x64
          helixQueuesTemplate: /eng/pipelines/coreclr/templates/helix-queues-setup.yml
          helixQueueGroup: libraries
          jobParameters:
            testScope: innerloop
            liveRuntimeBuildConfig: checked
            unifiedArtifactsName: Libraries_CheckedCoreCLR_BuildArtifacts_$(osGroup)$(osSubgroup)_$(archType)_$(_BuildConfig)
            helixArtifactsName: Libraries_CheckedCoreCLR_TestArtifacts_$(osGroup)$(osSubgroup)_$(archType)_$(_BuildConfig)
            unifiedBuildNameSuffix: Libraries_CheckedCoreCLR
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_coreclr.containsChange'], true),
                eq(variables['isRollingBuild'], true))

      #
      # Release Libraries Test Execution against a checked runtime
      # Only if CoreCLR or Libraries is changed
      #
      - template: /eng/pipelines/common/platform-matrix.yml
        parameters:
          jobTemplate: /eng/pipelines/libraries/run-test-job.yml
          buildConfig: Release
          platforms:
          - linux_musl_arm
          - linux_musl_arm64
          - linux_x64
          - windows_x64
          helixQueuesTemplate: /eng/pipelines/coreclr/templates/helix-queues-setup.yml
          helixQueueGroup: libraries
          jobParameters:
            testScope: innerloop
            liveRuntimeBuildConfig: checked
            unifiedArtifactsName: CoreCLR_ReleaseLibraries_BuildArtifacts_$(osGroup)$(osSubgroup)_$(archType)_Checked
            helixArtifactsName: CoreCLR_ReleaseLibraries_TestArtifacts_$(osGroup)$(osSubgroup)_$(archType)_Checked
            unifiedBuildNameSuffix: CoreCLR_ReleaseLibraries
            unifiedBuildConfigOverride: checked
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_coreclr.containsChange'], true),
                eq(variables['isRollingBuild'], true))

      - template: /eng/pipelines/common/platform-matrix.yml
        parameters:
          jobTemplate: /eng/pipelines/libraries/run-test-job.yml
          buildConfig: ${{ variables.debugOnPrReleaseOnRolling }}
          platforms:
          - osx_x64
          helixQueuesTemplate: /eng/pipelines/coreclr/templates/helix-queues-setup.yml
          helixQueueGroup: libraries
          jobParameters:
            testScope: innerloop
            liveRuntimeBuildConfig: checked
            unifiedArtifactsName: Libraries_CheckedCoreCLR_BuildArtifacts_$(osGroup)$(osSubgroup)_$(archType)_$(_BuildConfig)
            helixArtifactsName: Libraries_CheckedCoreCLR_TestArtifacts_$(osGroup)$(osSubgroup)_$(archType)_$(_BuildConfig)
            unifiedBuildNameSuffix: Libraries_CheckedCoreCLR
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_coreclr.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_libraries.containsChange'], true),
                eq(variables['isRollingBuild'], true))

      #
      # Build and test Mono Interpreter with the libraries testss
      #
      - template: /eng/pipelines/common/platform-matrix.yml
        parameters:
          jobTemplate: /eng/pipelines/common/global-build-job.yml
          helixQueuesTemplate: /eng/pipelines/libraries/helix-queues-setup.yml
          buildConfig: ${{ variables.debugOnPrReleaseOnRolling }}
          runtimeFlavor: mono
          runtimeVariant: monointerpreter
          platforms:
            - linux_x64
            #- osx_x64
            #- windows_x64
          jobParameters:
            testGroup: innerloop
            nameSuffix: Mono_Interpreter_LibrariesTests
            buildArgs: -s mono+libs+libs.tests -rc Release -c $(_BuildConfig) /p:ArchiveTests=true
            timeoutInMinutes: 480
            # extra steps, run tests
            postBuildSteps:
              - template: /eng/pipelines/libraries/helix.yml
                parameters:
                  creator: dotnet-bot
                  testRunNamePrefixSuffix: Mono_Interpreter_$(_BuildConfig)
                  interpreter: true
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_libraries.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_mono_excluding_wasm.containsChange'], true),
                eq(variables['isRollingBuild'], true))

      #
      # Build and test Mono Minijit with the libraries testss
      #
      - template: /eng/pipelines/common/platform-matrix.yml
        parameters:
          jobTemplate: /eng/pipelines/common/global-build-job.yml
          helixQueuesTemplate: /eng/pipelines/libraries/helix-queues-setup.yml
          buildConfig: ${{ variables.debugOnPrReleaseOnRolling }}
          runtimeFlavor: mono
          platforms:
            - linux_arm64
            - linux_x64
            - osx_x64
            #- windows_x64
          jobParameters:
            testGroup: innerloop
            nameSuffix: Mono_MiniJIT_LibrariesTests
            buildArgs: -s mono+libs+libs.tests -rc Release -c $(_BuildConfig) /p:ArchiveTests=true
            timeoutInMinutes: 480
            # extra steps, run tests
            postBuildSteps:
              - template: /eng/pipelines/libraries/helix.yml
                parameters:
                  creator: dotnet-bot
                  testRunNamePrefixSuffix: Mono_Minijit_$(_BuildConfig)
            condition: >-
              or(
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_libraries.containsChange'], true),
                eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_mono_excluding_wasm.containsChange'], true),
                eq(variables['isRollingBuild'], true))

      #
      # Sourcebuild legs
      # We have 3 important legs for source-build:
      # - Centos.8 (ensures that known non-portable RID is working)
      # - Linux-x64 portable (used for dependency flow and downstream PR verification)
      # - Banana.24 - Non-existent RID to ensure we don't break RIDs we don't know about.
      #
      # Running all of these everywhere is wasteful. Run Banana.24 and CentOS.8 in rolling CI,
      # Run Linux-x64 in PR.

      - template: /eng/pipelines/common/platform-matrix.yml
        parameters:
          jobTemplate: /eng/pipelines/common/global-build-job.yml
          buildConfig: Release
          helixQueueGroup: pr
          platforms:
          - SourceBuild_centos8_x64
          jobParameters:
            nameSuffix: centos8SourceBuild
            timeoutInMinutes: 95
            condition: eq(variables['isRollingBuild'], true)

      - template: /eng/pipelines/common/platform-matrix.yml
        parameters:
          jobTemplate: /eng/pipelines/common/global-build-job.yml
          buildConfig: Release
          helixQueueGroup: pr
          platforms:
          - SourceBuild_banana24_x64
          jobParameters:
            nameSuffix: banana24SourceBuild
            timeoutInMinutes: 95
            condition: eq(variables['isRollingBuild'], true)
